src/core/hle/service/psc/time/clocks/context_writers.cpp


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later

#include "core/core.h"
#include "core/hle/service/psc/time/clocks/context_writers.h"

namespace Service::PSC::Time {

void ContextWriter::SignalAllNodes() {
    std::scoped_lock l{m_mutex};
    for (auto& operation : m_operation_events) {
        operation.m_event->Signal();
    }
}

void ContextWriter::Link(OperationEvent& operation_event) {
    std::scoped_lock l{m_mutex};
    m_operation_events.push_back(operation_event);
}

LocalSystemClockContextWriter::LocalSystemClockContextWriter(Core::System& system,
                                                             SharedMemory& shared_memory)
    : m_system{system}, m_shared_memory{shared_memory} {}

Result LocalSystemClockContextWriter::Write(const SystemClockContext& context) {
    if (m_in_use) {
        R_SUCCEED_IF(context == m_context);
        m_context = context;
    } else {
        m_context = context;
        m_in_use = true;
    }

    m_shared_memory.SetLocalSystemContext(context);

    SignalAllNodes();

    R_SUCCEED();
}

NetworkSystemClockContextWriter::NetworkSystemClockContextWriter(Core::System& system,
                                                                 SharedMemory& shared_memory,
                                                                 SystemClockCore& system_clock)
    : m_system{system}, m_shared_memory{shared_memory}, m_system_clock{system_clock} {}

Result NetworkSystemClockContextWriter::Write(const SystemClockContext& context) {
    s64 time{};
    [[maybe_unused]] auto res = m_system_clock.GetCurrentTime(&time);

    if (m_in_use) {
        R_SUCCEED_IF(context == m_context);
        m_context = context;
    } else {
        m_context = context;
        m_in_use = true;
    }

    m_shared_memory.SetNetworkSystemContext(context);

    SignalAllNodes();

    R_SUCCEED();
}

EphemeralNetworkSystemClockContextWriter::EphemeralNetworkSystemClockContextWriter(
    Core::System& system)
    : m_system{system} {}

Result EphemeralNetworkSystemClockContextWriter::Write(const SystemClockContext& context) {
    if (m_in_use) {
        R_SUCCEED_IF(context == m_context);
        m_context = context;
    } else {
        m_context = context;
        m_in_use = true;
    }

    SignalAllNodes();

    R_SUCCEED();
}

} // namespace Service::PSC::Time